home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / pyxmpp / xmlextra.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  11.0 KB  |  398 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __revision__ = '$Id: xmlextra.py,v 1.15 2004/10/11 18:33:51 jajcus Exp $'
  5. __docformat__ = 'restructuredtext en'
  6. import sys
  7. import libxml2
  8. import threading
  9. import re
  10. from pyxmpp.exceptions import StreamParseError
  11. common_doc = libxml2.newDoc('1.0')
  12. common_root = common_doc.newChild(None, 'root', None)
  13. COMMON_NS = 'http://pyxmpp.jajcus.net/xmlns/common'
  14. common_ns = common_root.newNs(COMMON_NS, None)
  15. common_root.setNs(common_ns)
  16. common_doc.setRootElement(common_root)
  17.  
  18. class StreamHandler:
  19.     
  20.     def __init__(self):
  21.         pass
  22.  
  23.     
  24.     def _stream_start(self, _doc):
  25.         doc = libxml2.xmlDoc(_doc)
  26.         self.stream_start(doc)
  27.  
  28.     
  29.     def _stream_end(self, _doc):
  30.         doc = libxml2.xmlDoc(_doc)
  31.         self.stream_end(doc)
  32.  
  33.     
  34.     def _stanza(self, _doc, _node):
  35.         doc = libxml2.xmlDoc(_doc)
  36.         node = libxml2.xmlNode(_node)
  37.         self.stanza(doc, node)
  38.  
  39.     
  40.     def stream_start(self, doc):
  41.         print >>sys.stderr, 'Unhandled stream start:', `doc.serialize()`
  42.  
  43.     
  44.     def stream_end(self, doc):
  45.         print >>sys.stderr, 'Unhandled stream end', `doc.serialize()`
  46.  
  47.     
  48.     def stanza(self, _unused, node):
  49.         print >>sys.stderr, 'Unhandled stanza', `node.serialize()`
  50.  
  51.     
  52.     def error(self, descr):
  53.         raise StreamParseError, descr
  54.  
  55.  
  56.  
  57. try:
  58.     import _xmlextra
  59.     from _xmlextra import error
  60. except ImportError:
  61.     print >>sys.stderr, 'WARNING: using SLOW xmlextra'
  62.     
  63.     class error(Exception):
  64.         pass
  65.  
  66.     
  67.     def _escape(data):
  68.         data = data.replace('&', '&')
  69.         data = data.replace('<', '<')
  70.         data = data.replace('>', '>')
  71.         data = data.replace("'", ''')
  72.         data = data.replace('"', '"')
  73.         return data
  74.  
  75.     
  76.     class _SAXCallback(libxml2.SAXCallback):
  77.         
  78.         def __init__(self, handler):
  79.             self._handler = handler
  80.             self._head = ''
  81.             self._tail = ''
  82.             self._current = ''
  83.             self._level = 0
  84.             self._doc = None
  85.             self._root = None
  86.  
  87.         
  88.         def cdataBlock(self, data):
  89.             if self._level > 1:
  90.                 self._current += _escape(data)
  91.             
  92.  
  93.         
  94.         def characters(self, data):
  95.             if self._level > 1:
  96.                 self._current += _escape(data)
  97.             
  98.  
  99.         
  100.         def comment(self, content):
  101.             pass
  102.  
  103.         
  104.         def endDocument(self):
  105.             pass
  106.  
  107.         
  108.         def endElement(self, tag):
  109.             self._current += '</%s>' % (tag,)
  110.             self._level -= 1
  111.             if self._level == 1:
  112.                 xml = self._head + self._current + self._tail
  113.                 doc = libxml2.parseDoc(xml)
  114.                 
  115.                 try:
  116.                     node = doc.getRootElement().children
  117.                     
  118.                     try:
  119.                         node1 = node.docCopyNode(self._doc, 1)
  120.                         
  121.                         try:
  122.                             self._root.addChild(node1)
  123.                             self._handler.stanza(self._doc, node1)
  124.                         except Exception:
  125.                             None if self._level > 1 else self
  126.                             None if self._level > 1 else self
  127.                             import traceback
  128.                             traceback.print_exc()
  129.                         except:
  130.                             None if self._level > 1 else self
  131.                         finally:
  132.                             node1.unlinkNode()
  133.                             node1.freeNode()
  134.                             del node1
  135.  
  136.                     finally:
  137.                         del node
  138.  
  139.                 finally:
  140.                     doc.freeDoc()
  141.  
  142.             else:
  143.                 xml = self._head + self._tail
  144.                 doc = libxml2.parseDoc(xml)
  145.                 
  146.                 try:
  147.                     self._handler.stream_end(self._doc)
  148.                     self._doc.freeDoc()
  149.                     self._doc = None
  150.                     self._root = None
  151.                 finally:
  152.                     doc.freeDoc()
  153.  
  154.  
  155.         
  156.         def error(self, msg):
  157.             self._handler.error(msg)
  158.  
  159.         fatalError = error
  160.         ignorableWhitespace = characters
  161.         
  162.         def reference(self, name):
  163.             self._current += '&' + name + ';'
  164.  
  165.         
  166.         def startDocument(self):
  167.             pass
  168.  
  169.         
  170.         def startElement(self, tag, attrs):
  171.             s = '<' + tag
  172.             if attrs:
  173.                 for a, v in attrs.items():
  174.                     s += " %s='%s'" % (a, _escape(v))
  175.                 
  176.             
  177.             s += '>'
  178.             if self._level == 0:
  179.                 self._head = s
  180.                 self._tail = '</%s>' % (tag,)
  181.                 xml = self._head + self._tail
  182.                 self._doc = libxml2.parseDoc(xml)
  183.                 self._handler.stream_start(self._doc)
  184.                 self._root = self._doc.getRootElement()
  185.             elif self._level == 1:
  186.                 self._current = s
  187.             else:
  188.                 self._current += s
  189.             self._level += 1
  190.  
  191.         
  192.         def warning(self):
  193.             pass
  194.  
  195.  
  196.     
  197.     class _PythonReader:
  198.         
  199.         def __init__(self, handler):
  200.             self.handler = handler
  201.             self.sax = _SAXCallback(handler)
  202.             self.parser = libxml2.createPushParser(self.sax, '', 0, 'stream')
  203.  
  204.         
  205.         def feed(self, data):
  206.             return self.parser.parseChunk(data, len(data), 0)
  207.  
  208.  
  209.     _create_reader = _PythonReader
  210.     
  211.     def _get_ns(node):
  212.         
  213.         try:
  214.             return node.ns()
  215.         except libxml2.treeError:
  216.             return None
  217.  
  218.  
  219.     
  220.     def replace_ns(node, old_ns, new_ns):
  221.         if old_ns is not None:
  222.             old_ns_uri = old_ns.content
  223.             old_ns_prefix = old_ns.name
  224.         else:
  225.             old_ns_uri = None
  226.             old_ns_prefix = None
  227.         ns = _get_ns(node)
  228.         if ns is None and old_ns is None:
  229.             node.setNs(new_ns)
  230.         elif ns and ns.content == old_ns_uri and ns.name == old_ns_prefix:
  231.             node.setNs(new_ns)
  232.         
  233.         p = node.properties
  234.         while p:
  235.             ns = _get_ns(p)
  236.             if ns is None and old_ns is None:
  237.                 p.setNs(new_ns)
  238.             
  239.             if ns and ns.content == old_ns_uri and ns.name == old_ns_prefix:
  240.                 p.setNs(new_ns)
  241.             
  242.             p = p.next
  243.         n = node.children
  244.         while n:
  245.             if n.type == 'element':
  246.                 skip_element = False
  247.                 
  248.                 try:
  249.                     nsd = n.nsDefs()
  250.                 except libxml2.treeError:
  251.                     nsd = None
  252.  
  253.                 while nsd:
  254.                     if nsd.name == old_ns_prefix:
  255.                         skip_element = True
  256.                         break
  257.                     
  258.                     nsd = nsd.next
  259.                 if not skip_element:
  260.                     replace_ns(n, old_ns, new_ns)
  261.                 
  262.             
  263.             n = n.next
  264.  
  265.     pure_python = True
  266.  
  267. _create_reader = _xmlextra.sax_reader_new
  268.  
  269. def replace_ns(node, old_ns, new_ns):
  270.     if old_ns is None:
  271.         old_ns__o = None
  272.     else:
  273.         old_ns__o = old_ns._o
  274.     if new_ns is None:
  275.         new_ns__o = None
  276.     else:
  277.         new_ns__o = new_ns._o
  278.     if node is None:
  279.         node__o = None
  280.     else:
  281.         node__o = node._o
  282.     _xmlextra.replace_ns(node__o, old_ns__o, new_ns__o)
  283.     if old_ns__o:
  284.         _xmlextra.remove_ns(node__o, old_ns__o)
  285.     
  286.  
  287. pure_python = False
  288.  
  289. def get_node_ns(xmlnode):
  290.     
  291.     try:
  292.         return xmlnode.ns()
  293.     except libxml2.treeError:
  294.         return None
  295.  
  296.  
  297.  
  298. def get_node_ns_uri(xmlnode):
  299.     ns = get_node_ns(xmlnode)
  300.     if ns:
  301.         return unicode(ns.getContent(), 'utf-8')
  302.     else:
  303.         return None
  304.  
  305.  
  306. def xml_node_iter(nodelist):
  307.     node = nodelist
  308.     while node:
  309.         yield node
  310.         node = node.next
  311.  
  312.  
  313. def xml_element_iter(nodelist):
  314.     node = nodelist
  315.     while node:
  316.         if node.type == 'element':
  317.             yield node
  318.         
  319.         node = node.next
  320.  
  321.  
  322. def xml_element_ns_iter(nodelist, ns_uri):
  323.     node = nodelist
  324.     while node:
  325.         if node.type == 'element' and get_node_ns_uri(node) == ns_uri:
  326.             yield node
  327.         
  328.         node = node.next
  329.  
  330. evil_characters_re = re.compile('[\\000-\\010\\013\\014\\016-\\037]', re.UNICODE)
  331. utf8_replacement_char = u'∩┐╜'.encode('utf-8')
  332.  
  333. def remove_evil_characters(s):
  334.     if isinstance(s, unicode):
  335.         return evil_characters_re.sub(u'∩┐╜', s)
  336.     else:
  337.         return evil_characters_re.sub(utf8_replacement_char, s)
  338.  
  339. bad_nsdef_replace_re = re.compile('^([^<]*\\<[^><]*\\s+)(xmlns=((\\"[^\\"]*\\")|(\\\'[^\\\']*\\\')))')
  340.  
  341. def safe_serialize(xmlnode):
  342.     
  343.     try:
  344.         ns = xmlnode.ns()
  345.     except libxml2.treeError:
  346.         ns = None
  347.  
  348.     
  349.     try:
  350.         nsdef = xmlnode.nsDefs()
  351.     except libxml2.treeError:
  352.         nsdef = None
  353.  
  354.     s = xmlnode.serialize(encoding = 'UTF-8')
  355.     while nsdef:
  356.         if nsdef.name is None:
  357.             if not ns or (nsdef.name, nsdef.content) != (ns.name, ns.content):
  358.                 s = bad_nsdef_replace_re.sub('\\1', s, 1)
  359.                 break
  360.             
  361.         nsdef = nsdef.next
  362.     s = remove_evil_characters(s)
  363.     return s
  364.  
  365.  
  366. class StreamReader:
  367.     
  368.     def __init__(self, handler):
  369.         self.reader = _create_reader(handler)
  370.         self.lock = threading.RLock()
  371.         self.in_use = 0
  372.  
  373.     
  374.     def doc(self):
  375.         ret = self.reader.doc()
  376.         if ret:
  377.             return libxml2.xmlDoc(ret)
  378.         else:
  379.             return None
  380.  
  381.     
  382.     def feed(self, s):
  383.         self.lock.acquire()
  384.         if self.in_use:
  385.             self.lock.release()
  386.             raise StreamParseError, 'StreamReader.feed() is not reentrant!'
  387.         
  388.         self.in_use = 1
  389.         
  390.         try:
  391.             return self.reader.feed(s)
  392.         finally:
  393.             self.in_use = 0
  394.             self.lock.release()
  395.  
  396.  
  397.  
  398.